// VideoType.js - 视频类型模型
const { sequelize } = require('../config/db');

class VideoType {
  constructor(type_id, name, description, created_at, updated_at) {
    this.type_id = type_id;
    this.name = name;
    this.description = description;
    this.created_at = created_at;
    this.updated_at = updated_at;
  }

  /**
   * 根据ID获取视频类型
   * @param {number} type_id - 视频类型ID
   * @returns {Promise<VideoType|null>} - 视频类型对象或null
   */
  static async getById(type_id) {
    try {
      const query = 'SELECT * FROM video_type WHERE type_id = ?';
      // 使用原始查询，不使用QueryTypes
      const result = await sequelize.query(query, {
        replacements: [type_id],
        raw: true
      });
      
      // 处理返回结果，兼容不同版本的Sequelize
      const data = Array.isArray(result) ? result[0] : result;
      
      if (!data || data.length === 0) return null;
      
      const type = data[0];
      return new VideoType(
        type.type_id,
        type.name,
        type.description,
        type.created_at,
        type.updated_at
      );
    } catch (error) {
      console.error('获取视频类型失败:', error);
      throw error;
    }
  }

  /**
   * 获取所有视频类型
   * @returns {Promise<Array<VideoType>>} - 视频类型列表
   */
  static async getAll() {
    try {
      const query = 'SELECT * FROM video_type ORDER BY type_id ASC';
      // 使用原始查询，不使用QueryTypes
      const result = await sequelize.query(query, {
        raw: true
      });
      
      // 处理返回结果，兼容不同版本的Sequelize
      const data = Array.isArray(result) ? result[0] : result;
      
      const types = [];
      for (let i = 0; i < data.length; i++) {
        const type = data[i];
        types.push(new VideoType(
          type.type_id,
          type.name,
          type.description,
          type.created_at,
          type.updated_at
        ));
      }
      return types;
    } catch (error) {
      console.error('获取所有视频类型失败:', error);
      throw error;
    }
  }

  /**
   * 创建新的视频类型
   * @param {string} name - 视频类型名称
   * @param {string} description - 视频类型描述
   * @returns {Promise<VideoType>} - 创建的视频类型对象
   */
  static async create(name, description) {
    try {
      const query = `
        INSERT INTO video_type (name, description)
        VALUES (?, ?)
      `;
      
      // 直接执行查询，不使用QueryTypes
      await sequelize.query(query, {
        replacements: [name, description],
        raw: true
      });
      
      // 获取插入的ID，使用简单的查询
      const idQuery = 'SELECT LAST_INSERT_ID() as type_id';
      const idResult = await sequelize.query(idQuery, {
        raw: true
      });
      
      // 处理ID结果
      let newTypeId;
      if (Array.isArray(idResult) && idResult.length > 0) {
        if (Array.isArray(idResult[0]) && idResult[0].length > 0) {
          newTypeId = idResult[0][0].type_id;
        } else {
          newTypeId = idResult[0].type_id;
        }
      } else {
        throw new Error('无法获取新创建的视频类型ID');
      }
      
      return await VideoType.getById(newTypeId);
    } catch (error) {
      console.error('创建视频类型失败:', error);
      throw error;
    }
  }

  /**
   * 更新视频类型
   * @param {number} type_id - 视频类型ID
   * @param {object} data - 更新的数据
   * @returns {Promise<VideoType|null>} - 更新后的视频类型对象或null
   */
  static async update(type_id, data) {
    try {
      // 先检查记录是否存在
      const existing = await VideoType.getById(type_id);
      if (!existing) {
        return null;
      }
      
      // 构建更新字段和值
      const fields = [];
      const values = [];
      
      if (data.name !== undefined) {
        fields.push('name = ?');
        values.push(data.name);
      }
      
      if (data.description !== undefined) {
        fields.push('description = ?');
        values.push(data.description);
      }
      
      // 添加更新时间
      fields.push('updated_at = NOW()');
      
      // 如果没有要更新的字段，直接返回当前类型
      if (fields.length === 0) {
        return existing;
      }
      
      // 添加ID到参数末尾
      values.push(type_id);
      
      const query = `
        UPDATE video_type 
        SET ${fields.join(', ')} 
        WHERE type_id = ?
      `;
      
      // 直接执行查询
      await sequelize.query(query, {
        replacements: values,
        raw: true
      });
      
      // 返回更新后的记录
      return await VideoType.getById(type_id);
    } catch (error) {
      console.error('更新视频类型失败:', error);
      throw error;
    }
  }

  /**
   * 删除视频类型
   * @param {number} type_id - 视频类型ID
   * @returns {Promise<boolean>} - 是否删除成功
   */
  static async delete(type_id) {
    try {
      // 先检查记录是否存在
      const exists = await VideoType.getById(type_id);
      if (!exists) {
        return false;
      }
      
      // 执行删除操作，使用简单的方式
      const query = 'DELETE FROM video_type WHERE type_id = ?';
      
      // 直接执行删除，不关心返回值
      await sequelize.query(query, {
        replacements: [type_id],
        raw: true
      });
      
      // 再次检查记录是否存在来确认删除是否成功
      const stillExists = await VideoType.getById(type_id);
      return !stillExists;
    } catch (error) {
      console.error('删除视频类型失败:', error);
      throw error;
    }
  }

  /**
   * 检查视频类型名称是否已存在
   * @param {string} name - 视频类型名称
   * @param {number} excludeId - 排除的类型ID（用于更新时）
   * @returns {Promise<boolean>} - 是否已存在
   */
  static async exists(name, excludeId = null) {
    try {
      let query = 'SELECT COUNT(*) as count FROM video_type WHERE name = ?';
      const replacements = [name];
      
      if (excludeId !== null) {
        query += ' AND type_id != ?';
        replacements.push(excludeId);
      }
      
      // 直接执行查询
      const result = await sequelize.query(query, {
        replacements: replacements,
        raw: true
      });
      
      // 处理返回结果
      let count = 0;
      if (Array.isArray(result) && result.length > 0) {
        if (Array.isArray(result[0]) && result[0].length > 0) {
          count = result[0][0].count;
        } else {
          count = result[0].count;
        }
      }
      
      return count > 0;
    } catch (error) {
      console.error('检查视频类型名称失败:', error);
      throw error;
    }
  }
}

module.exports = VideoType;